/**
 * 工具函数模块
 */

const utils = {
    /**
     * 格式化日期
     * @param {string|Date} date - 日期对象或日期字符串
     * @param {string} format - 格式化模板，默认为 'YYYY-MM-DD'
     * @returns {string} 格式化后的日期字符串
     */
    formatDate(date, format = 'YYYY-MM-DD') {
        const d = typeof date === 'string' ? new Date(date) : date;
        
        if (isNaN(d.getTime())) {
            return '';
        }
        
        const year = d.getFullYear();
        const month = String(d.getMonth() + 1).padStart(2, '0');
        const day = String(d.getDate()).padStart(2, '0');
        const hours = String(d.getHours()).padStart(2, '0');
        const minutes = String(d.getMinutes()).padStart(2, '0');
        const seconds = String(d.getSeconds()).padStart(2, '0');
        
        return format
            .replace('YYYY', year)
            .replace('MM', month)
            .replace('DD', day)
            .replace('HH', hours)
            .replace('mm', minutes)
            .replace('ss', seconds);
    },

    /**
     * 计算阅读时间
     * @param {string} text - 文章内容
     * @param {number} wordsPerMinute - 每分钟阅读字数，默认300
     * @returns {string} 阅读时间字符串
     */
    calculateReadTime(text, wordsPerMinute = 300) {
        if (!text || typeof text !== 'string') {
            return '0 分钟';
        }
        
        const chineseChars = text.match(/[\u4e00-\u9fa5]/g) || [];
        const chineseCount = chineseChars.length;
        
        // 匹配英文单词
        const englishWords = text.match(/\b[a-zA-Z]+\b/g) || [];
        const englishCount = englishWords.length;
        
        // 总字数 = 中文字数 + 英文单词数
        const totalWords = chineseCount + englishCount;
        const minutes = Math.ceil(totalWords / wordsPerMinute);
        
        return `${minutes} 分钟`;
    },

    /**
     * 截取字符串
     * @param {string} str - 原始字符串
     * @param {number} length - 截取长度
     * @param {string} suffix - 后缀，默认为 '...'
     * @returns {string} 截取后的字符串
     */
    truncateString(str, length = 100, suffix = '...') {
        if (!str || typeof str !== 'string') {
            return '';
        }
        
        if (str.length <= length) {
            return str;
        }
        
        return str.substring(0, length) + suffix;
    },

    /**
     * 防抖函数
     * @param {Function} func - 要执行的函数
     * @param {number} wait - 等待时间（毫秒）
     * @returns {Function} 防抖处理后的函数
     */
    debounce(func, wait = 300) {
        let timeout;
        
        return function executedFunction(...args) {
            const later = () => {
                clearTimeout(timeout);
                func(...args);
            };
            
            clearTimeout(timeout);
            timeout = setTimeout(later, wait);
        };
    },

    /**
     * 节流函数
     * @param {Function} func - 要执行的函数
     * @param {number} limit - 时间限制（毫秒）
     * @returns {Function} 节流处理后的函数
     */
    throttle(func, limit = 300) {
        let inThrottle;
        
        return function(...args) {
            if (!inThrottle) {
                func.apply(this, args);
                inThrottle = true;
                setTimeout(() => inThrottle = false, limit);
            }
        };
    },

    /**
     * 获取URL参数
     * @param {string} name - 参数名
     * @returns {string|null} 参数值，如果不存在则返回null
     */
    getUrlParameter(name) {
        const url = window.location.href;
        name = name.replace(/[\[\]]/g, '\\$&');
        const regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)');
        const results = regex.exec(url);
        
        if (!results) return null;
        if (!results[2]) return '';
        
        return decodeURIComponent(results[2].replace(/\+/g, ' '));
    },

    /**
     * 滚动到指定元素
     * @param {string|HTMLElement} element - 元素选择器或元素对象
     * @param {number} offset - 偏移量（像素）
     * @param {number} duration - 动画持续时间（毫秒）
     */
    scrollToElement(element, offset = 0, duration = 500) {
        const target = typeof element === 'string' 
            ? document.querySelector(element)
            : element;
        
        if (!target) return;
        
        const targetPosition = target.getBoundingClientRect().top + window.pageYOffset + offset;
        const startPosition = window.pageYOffset;
        const distance = targetPosition - startPosition;
        let startTime = null;
        
        const animation = currentTime => {
            if (startTime === null) startTime = currentTime;
            const timeElapsed = currentTime - startTime;
            const run = ease(timeElapsed, startPosition, distance, duration);
            window.scrollTo(0, run);
            if (timeElapsed < duration) requestAnimationFrame(animation);
        };
        
        const ease = (t, b, c, d) => {
            t /= d / 2;
            if (t < 1) return c / 2 * t * t + b;
            t--;
            return -c / 2 * (t * (t - 2) - 1) + b;
        };
        
        requestAnimationFrame(animation);
    },

    /**
     * 检查元素是否在视口中
     * @param {HTMLElement} element - 要检查的元素
     * @param {Object} options - 选项
     * @returns {boolean} 是否在视口中
     */
    isElementInViewport(element, options = {}) {
        const {
            top = 0,
            right = 0,
            bottom = 0,
            left = 0
        } = options;
        
        const rect = element.getBoundingClientRect();
        
        return (
            rect.top >= top &&
            rect.left >= left &&
            rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) - bottom &&
            rect.right <= (window.innerWidth || document.documentElement.clientWidth) - right
        );
    },

    /**
     * 深拷贝对象
     * @param {*} obj - 要拷贝的对象
     * @returns {*} 拷贝后的对象
     */
    deepClone(obj) {
        if (obj === null || typeof obj !== 'object') {
            return obj;
        }
        
        if (obj instanceof Date) {
            return new Date(obj.getTime());
        }
        
        if (obj instanceof Array) {
            return obj.map(item => this.deepClone(item));
        }
        
        if (obj instanceof Object) {
            const clonedObj = {};
            for (const key in obj) {
                if (obj.hasOwnProperty(key)) {
                    clonedObj[key] = this.deepClone(obj[key]);
                }
            }
            return clonedObj;
        }
    },

    /**
     * 存储数据到本地存储
     * @param {string} key - 存储键名
     * @param {*} value - 要存储的值
     */
    setLocalStorage(key, value) {
        try {
            const serializedValue = JSON.stringify(value);
            localStorage.setItem(key, serializedValue);
        } catch (error) {
            console.error('Error saving to localStorage:', error);
        }
    },

    /**
     * 从本地存储获取数据
     * @param {string} key - 存储键名
     * @param {*} defaultValue - 默认值
     * @returns {*} 存储的值或默认值
     */
    getLocalStorage(key, defaultValue = null) {
        try {
            const serializedValue = localStorage.getItem(key);
            if (serializedValue === null) {
                return defaultValue;
            }
            return JSON.parse(serializedValue);
        } catch (error) {
            console.error('Error reading from localStorage:', error);
            return defaultValue;
        }
    },

    /**
     * 从本地存储删除数据
     * @param {string} key - 存储键名
     */
    removeLocalStorage(key) {
        try {
            localStorage.removeItem(key);
        } catch (error) {
            console.error('Error removing from localStorage:', error);
        }
    },

    /**
     * 清空本地存储
     */
    clearLocalStorage() {
        try {
            localStorage.clear();
        } catch (error) {
            console.error('Error clearing localStorage:', error);
        }
    },

    /**
     * 验证邮箱格式
     * @param {string} email - 邮箱地址
     * @returns {boolean} 是否有效
     */
    isValidEmail(email) {
        const re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
        return re.test(email);
    },

    /**
     * 生成唯一ID
     * @returns {string} 唯一ID
     */
    generateUniqueId() {
        return Date.now().toString(36) + Math.random().toString(36).substring(2);
    },

    /**
     * 随机打乱数组
     * @param {Array} array - 原始数组
     * @returns {Array} 打乱后的数组
     */
    shuffleArray(array) {
        const newArray = [...array];
        for (let i = newArray.length - 1; i > 0; i--) {
            const j = Math.floor(Math.random() * (i + 1));
            [newArray[i], newArray[j]] = [newArray[j], newArray[i]];
        }
        return newArray;
    },

    /**
     * 数组去重
     * @param {Array} array - 原始数组
     * @returns {Array} 去重后的数组
     */
    uniqueArray(array) {
        return [...new Set(array)];
    },

    /**
     * 数字千分位格式化
     * @param {number} num - 要格式化的数字
     * @returns {string} 格式化后的字符串
     */
    formatNumber(num) {
        return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
    }
};

// 导出工具对象
if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
    module.exports = utils;
} else {
    window.utils = utils;
}